doc
Module Contents
alltypes
Module Contents
interface AbsentThrowableMessageProviderFactory
object AbsentThrowableMessageProviderFactoryBuilder : AbsentThrowableMessageProviderFactory
interface AnyAssertions
object AnyAssertionsBuilder : AnyAssertions
interface AnyTypeTransformation
interface AnyTypeTransformation
interface AnyTypeTransformationAssertions
Module Contents
abstract fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: FailureHandler<T, TSub>): Unit
abstract fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
abstract fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreator: AssertionPlant<T>.() -> Unit): Unit
abstract fun <S : Any, T : Any> transform(parameterObject: ParameterObject<S, T>, canBeTransformed: (S) -> Boolean, transform: (S) -> T, failureHandler: FailureHandler<S, T>): Unit
object AnyTypeTransformationAssertionsBuilder : AnyTypeTransformationAssertions
Module Contents
inline fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: FailureHandler<T, TSub>): <ERROR CLASS>
inline val failureHandlers: AnyTypeTransformationFailureHandlerFactoryBuilder
inline fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): <ERROR CLASS>
inline fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): <ERROR CLASS>
inline fun <S : Any, T : Any> transform(parameterObject: ParameterObject<S, T>, noinline canBeTransformed: (S) -> Boolean, noinline transform: (S) -> T, failureHandler: FailureHandler<S, T>): <ERROR CLASS>
object AnyTypeTransformationFailureHandlerFactoryBuilder : FailureHandlerFactory
abstract class ArgumentsSupportingTranslator : Translator
typealias Assert<T> = AssertionPlant<T>
object AssertImpl
@DslMarker annotation class AssertMarker
interface Assertion
interface AssertionBuilder
interface AssertionBuilderFinalStep<T : Assertion>
interface AssertionChecker
interface AssertionCollector
object AssertionCollectorBuilder : AssertionCollector
interface AssertionComposer
interface AssertionFormatter
data class AssertionFormatterChosenOptions
interface AssertionFormatterController
interface AssertionFormatterControllerOption
interface AssertionFormatterFacade
interface AssertionFormatterFacadeOption
class AssertionFormatterParameterObject
interface AssertionGroup : Assertion
interface AssertionGroupDescriptionAndEmptyRepresentationOption<out T : AssertionGroupType, R>
interface AssertionGroupDescriptionAndRepresentationOption<out T : AssertionGroupType, R>
interface AssertionGroupType : BulletPointIdentifier
interface AssertionPairFormatter
interface AssertionPairFormatterOption
interface AssertionPlant<out T : Any> : BaseAssertionPlant<T, AssertionPlant<T>>
interface AssertionPlantNullable<out T> : BaseAssertionPlant<T, AssertionPlantNullable<T>>
interface AssertionPlantWithCommonFields<out T>
enum class AssertionVerb : StringBasedTranslatable
enum class AssertionVerb : StringBasedTranslatable
object AssertionVerbFactory
interface AssertionsOption<out T : AssertionGroupType, R>
Module Contents
fun <T : AssertionGroupType> asFactoryWithDefaultFinalStep(): (T, Translatable, Any) -> AssertionsOption<T, BasicAssertionGroupFinalStep>
fun <T : AssertionGroupType, R> create(groupType: T, description: Translatable, representation: Any, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
abstract val description: Translatable
abstract val groupType: T
abstract val representation: Any
open fun withAssertion(assertion: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion, assertion3: Assertion): R
abstract fun withAssertions(assertions: List<Assertion>): R
fun <T : AssertionGroupType> withDefaultFinalStepAndEmptyDescriptionAndRepresentation(groupType: T): AssertionsOption<T, BasicAssertionGroupFinalStep>
fun <T : AssertionGroupType, R> withEmptyDescriptionAndRepresentation(groupType: T, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class AtLeastCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
abstract class AtLeastCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>
open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>
open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>
open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class AtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
abstract class AtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>
open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>
open class AtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>
open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>
interface BaseAssertionPlant<out T, out A : BaseAssertionPlant<T, A>>
interface BaseReportingAssertionPlant<out T, out A : BaseAssertionPlant<T, A>> : BaseAssertionPlant<T, A>, AssertionPlantWithCommonFields<T>
data class BasicAssertionGroup : AssertionGroup
interface BasicAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>
class BasicDescriptiveAssertion : DescriptiveAssertion
class BasicExplanatoryAssertion : ExplanatoryAssertion
interface BigDecimalAssertions
object BigDecimalAssertionsBuilder : BigDecimalAssertions
interface BulletPointIdentifier
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class ButAtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
Module Contents
ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<T, S>, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<T, S>
val times: Int
abstract class ButAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
Module Contents
ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<E, T, S>, containsBuilder: Builder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<E, T, S>
val times: Int
open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>
open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>
open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>
open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>
interface CharSequenceAssertions
object CharSequenceAssertionsBuilder : CharSequenceAssertions
interface CharSequenceContains
interface CharSequenceContains
class CharSequenceContainsAssertionCreator<T : CharSequence, S : SearchBehaviour> : ContainsObjectsAssertionCreator<T, Any, S, Checker>, Creator<T, Any>
interface CharSequenceContainsAssertions
Module Contents
abstract fun <T : CharSequence> defaultTranslationOf(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> regex(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> regexIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> values(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Any>): AssertionGroup
abstract fun <T : CharSequence> valuesIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Any>): AssertionGroup
object CharSequenceContainsAssertionsBuilder : CharSequenceContainsAssertions
Module Contents
inline fun <T : CharSequence> defaultTranslationOf(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): <ERROR CLASS>
inline fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): <ERROR CLASS>
inline fun <T : CharSequence> regex(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<String>): <ERROR CLASS>
inline fun <T : CharSequence> regexIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): <ERROR CLASS>
inline val searchBehaviours: CharSequenceContainsSearchBehaviourFactoryBuilder
inline fun <T : CharSequence> values(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Any>): <ERROR CLASS>
inline fun <T : CharSequence> valuesIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Any>): <ERROR CLASS>
class CharSequenceContainsAtLeastChecker : CharSequenceContainsChecker
open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsAtLeastCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
class CharSequenceContainsAtMostChecker : CharSequenceContainsChecker
open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
class CharSequenceContainsBuilder<out T : CharSequence, out S : SearchBehaviour> : ContainsBuilder<T, S>, Builder<T, S>
open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsButAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
Module Contents
CharSequenceContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilderBase<T, S>, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: Builder<T, S>
val times: Int
abstract class CharSequenceContainsChecker : ContainsChecker, Checker
interface CharSequenceContainsCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ContainsCheckerBuilder<T, S, Checker, Builder<T, S>>, CheckerOption<T, S>
class CharSequenceContainsExactlyChecker : CharSequenceContainsChecker
open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsExactlyCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
class CharSequenceContainsIgnoringCaseIndexSearcher : Searcher<CharSequenceContainsIgnoringCaseSearchBehaviour>
class CharSequenceContainsIgnoringCaseRegexSearcher : Searcher<CharSequenceContainsIgnoringCaseSearchBehaviour>
open class CharSequenceContainsIgnoringCaseSearchBehaviour : SearchBehaviour, IgnoringCaseSearchBehaviour
class CharSequenceContainsIndexSearcher : Searcher<CharSequenceContainsNoOpSearchBehaviour>
open class CharSequenceContainsNoOpSearchBehaviour : SearchBehaviour, NoOpSearchBehaviour
class CharSequenceContainsNotChecker : Checker
open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsNotCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsNotOrAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotSearchBehaviour : CharSequenceContainsNoOpSearchBehaviour, NotSearchBehaviour
class CharSequenceContainsRegexSearcher : Searcher<CharSequenceContainsNoOpSearchBehaviour>
object CharSequenceContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory
object CharSequenceContainsSearchersKt
Module Contents
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> standardUebersetzungVon(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> wert(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> werte(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
object CharSequenceContainsSearchersKt
Module Contents
fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> values(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
object CharSequenceContainsSearchersKt
Module Contents
fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>
interface CheckerFactory
interface CheckerFactory
interface CheckingAssertionPlant<out T : Any> : AssertionPlant<T>
interface CollectingAssertionPlant<out T : Any> : AssertionPlant<T>
interface CollectionAssertions
object CollectionAssertionsBuilder : CollectionAssertions
interface ComparableAssertions
object ComparableAssertionsBuilder : ComparableAssertions
interface Contains
interface Contains
abstract class ContainsAssertionCreator<T : Any, S, C : Checker> : Creator<T, S>
abstract class ContainsBuilder<out T : Any, out S : SearchBehaviour> : Builder<T, S>
abstract class ContainsChecker : Checker
interface ContainsCheckerBuilder<out T : Any, out S : SearchBehaviour, out C : Checker, out B : Builder<T, S>> : CheckerOption<T, S, C, B>
abstract class ContainsObjectsAssertionCreator<T : Any, S, B : SearchBehaviour, C : Checker> : ContainsAssertionCreator<T, S, C>
interface CoreFactory
Module Contents
abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subjectProvider: () -> T): CheckingAssertionPlant<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun <T : Any> newFeatureAssertionChecker(subjectPlant: AssertionPlant<T>): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade): Reporter
abstract fun newPropertiesBasedTranslationSupplier(): TranslationSupplier
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
abstract fun <T> newReportingPlantNullable(commonFields: CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSummaryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, fallbackLocales: List<Locale>): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit
typealias DefaultAssertionGroupBuilderOptions<T> = AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, BasicAssertionGroupFinalStep>>
object DefaultExplanatoryAssertionGroupType : ExplanatoryAssertionGroupType
object DefaultFeatureAssertionGroupType : FeatureAssertionGroupType
object DefaultIndentAssertionGroupType : IndentAssertionGroupType
object DefaultListAssertionGroupType : ListAssertionGroupType
object DefaultSummaryAssertionGroupType : SummaryAssertionGroupType
class DefaultTranslationsOf
class DeprecationTestEngine
enum class DescriptionAnyAssertion : StringBasedTranslatable
enum class DescriptionAnyAssertion : StringBasedTranslatable
enum class DescriptionBasic : StringBasedTranslatable
enum class DescriptionBasic : StringBasedTranslatable
enum class DescriptionBigDecimalAssertion : StringBasedTranslatable
enum class DescriptionBigDecimalAssertion : StringBasedTranslatable
enum class DescriptionCharSequenceAssertion : StringBasedTranslatable
enum class DescriptionCharSequenceAssertion : StringBasedTranslatable
enum class DescriptionCollectionAssertion : StringBasedTranslatable
enum class DescriptionCollectionAssertion : StringBasedTranslatable
enum class DescriptionComparableAssertion : StringBasedTranslatable
enum class DescriptionComparableAssertion : StringBasedTranslatable
enum class DescriptionFloatingPointAssertion : StringBasedTranslatable
enum class DescriptionFloatingPointAssertion : StringBasedTranslatable
enum class DescriptionIterableAssertion : StringBasedTranslatable
enum class DescriptionIterableAssertion : StringBasedTranslatable
enum class DescriptionMapAssertion : StringBasedTranslatable
enum class DescriptionThrowableAssertion : StringBasedTranslatable
enum class DescriptionThrowableAssertion : StringBasedTranslatable
enum class DescriptionTypeTransformationAssertion : StringBasedTranslatable
enum class DescriptionTypeTransformationAssertion : StringBasedTranslatable
interface DescriptiveAssertion : Assertion
interface DescriptiveAssertionFinalStep : AssertionBuilderFinalStep<DescriptiveAssertion>
interface DescriptiveAssertionHoldsOption
interface DescriptiveAssertionWithFailureHintFinalStep : AssertionBuilderFinalStep<Assertion>
interface DescriptiveAssertionWithFailureHintShowOption
interface DescriptiveLikeAssertionDescriptionOption<R>
interface DoNotFilterAssertionGroupType : AssertionGroupType
class DownCaster<T : Any, TSub : T>
class Eintraege<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>
class Eintrag<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>
object Empty
object Empty
open class EmptyNameAndRepresentationAssertionGroup : AssertionGroup
class Entries<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>
class Entries<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>
class Entries<in T : Any, out A : (Assert<T>) -> Unit>
class Entry<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>
class Entry<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class ExactlyCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
abstract class ExactlyCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>
open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>
open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>
open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>
object ExplainingAssertionCollectorOption
interface ExplanatoryAssertion : Assertion
interface ExplanatoryAssertionExplanationOption
interface ExplanatoryAssertionFinalStep : AssertionBuilderFinalStep<ExplanatoryAssertion>
class ExplanatoryAssertionGroup : EmptyNameAndRepresentationAssertionGroup
interface ExplanatoryAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>
interface ExplanatoryAssertionGroupType : DoNotFilterAssertionGroupType
interface ExplanatoryAssertionGroupTypeOption
class ExplanatoryTypeTransformationFailureHandler<T : Any, out TSub : T> : TypeTransformationFailureHandler<T, TSub>
interface FailureHandlerFactory
interface FeatureAssertionGroupType : AssertionGroupType
interface FeatureAssertions
Module Contents
abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlant<R>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
object FeatureAssertionsBuilder : FeatureAssertions
Module Contents
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
interface FixedClaimAssertionGroupFinalStep : BasicAssertionGroupFinalStep
interface FixedClaimAssertionGroupHoldsOption<T : AssertionGroupType>
interface FixedClaimAssertionGroupTypeOption
interface FloatingPointAssertions
object FloatingPointAssertionsBuilder : FloatingPointAssertions
class ForgivingTest
interface Group<out T>
interface GroupWithNullableEntries<out T> : Group<T>
interface GroupWithoutNullableEntries<out T : Any> : Group<T>
interface IAtriumFactory
Module Contents
abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subject: T): CheckingAssertionPlant<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun <T : Any> newFeatureAssertionChecker(subjectPlant: AssertionPlant<T>): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade): Reporter
abstract fun newPropertiesBasedTranslationSupplier(): TranslationSupplier
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subject: T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, reporter: Reporter, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker, nullRepresentation: Any): ReportingAssertionPlantNullable<T>
abstract fun <T> newReportingPlantNullable(commonFields: CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, vararg fallbackLocales: Locale): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit
interface IgnoringCaseSearchBehaviour : SearchBehaviour
interface InAnyOrderOnlySearchBehaviour : SearchBehaviour
interface InAnyOrderSearchBehaviour : SearchBehaviour
interface InOrderOnlyGroupedSearchBehaviour : SearchBehaviour
interface InOrderOnlyGroupedWithinSearchBehaviour : InOrderOnlyGroupedSearchBehaviour
interface InOrderOnlySearchBehaviour : SearchBehaviour
interface InOrderSearchBehaviour : SearchBehaviour
class IndentAssertionGroup : EmptyNameAndRepresentationAssertionGroup
interface IndentAssertionGroupType : AssertionGroupType
class InvisibleAssertionGroup : EmptyNameAndRepresentationAssertionGroup
object InvisibleAssertionGroupType : AssertionGroupType
interface IterableAssertions
object IterableAssertionsBuilder : IterableAssertions
interface IterableContains
interface IterableContains
Module Contents
interface Builder<out E, out T : Iterable<E>, out S : SearchBehaviour> : Builder<T, S>
interface Checker : Checker
interface CheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<T, S, Checker, Builder<E, T, S>>
interface Creator<in T : Iterable<*>, in SC> : Creator<T, SC>
interface SearchBehaviour : SearchBehaviour
interface IterableContainsAssertions
Module Contents
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<AssertionPlant<E>.() -> Unit>>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnly(builder: Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion
object IterableContainsAssertionsBuilder : IterableContainsAssertions
Module Contents
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<AssertionPlant<E>.() -> Unit>>): Assertion
inline val searchBehaviours: IterableContainsSearchBehaviourFactoryBuilder
inline fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInOrderOnly(builder: Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion
class IterableContainsAtLeastChecker : IterableContainsChecker
open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
abstract class IterableContainsAtLeastCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
class IterableContainsAtMostChecker : IterableContainsChecker
open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
abstract class IterableContainsAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
open class IterableContainsBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : ContainsBuilder<T, S>, Builder<E, T, S>
open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
abstract class IterableContainsButAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
Module Contents
IterableContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilderBase<E, T, S>, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int
abstract class IterableContainsChecker : ContainsChecker, Checker
interface IterableContainsCheckerBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : ContainsCheckerBuilder<T, S, Checker, Builder<E, T, S>>, CheckerOption<E, T, S>
class IterableContainsExactlyChecker : IterableContainsChecker
open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
abstract class IterableContainsExactlyCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
open class IterableContainsInAnyOrderEntriesAssertionCreator<E : Any, T : Iterable<E?>> : ContainsAssertionCreator<T, AssertionPlant<E>.() -> Unit, Checker>, Creator<T, AssertionPlant<E>.() -> Unit>
class IterableContainsInAnyOrderObjectsAssertionCreator<S, T : Iterable<S>> : ContainsObjectsAssertionCreator<T, S, IterableContainsInAnyOrderSearchBehaviour, Checker>, Creator<T, S>
abstract class IterableContainsInAnyOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : Creator<T, SC>
class IterableContainsInAnyOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, AssertionPlant<E>.() -> Unit>
class IterableContainsInAnyOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, E>
open class IterableContainsInAnyOrderOnlySearchBehaviour : SearchBehaviour, InAnyOrderOnlySearchBehaviour
open class IterableContainsInAnyOrderSearchBehaviour : SearchBehaviour, InAnyOrderSearchBehaviour
abstract class IterableContainsInOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : Creator<T, SC>
class IterableContainsInOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, AssertionPlant<E>.() -> Unit>
class IterableContainsInOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, E>
open class IterableContainsInOrderOnlySearchBehaviour : SearchBehaviour, InOrderOnlySearchBehaviour
open class IterableContainsInOrderSearchBehaviour : SearchBehaviour, InOrderSearchBehaviour
class IterableContainsNoOpCheckerBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
open class IterableContainsNoOpSearchBehaviour : SearchBehaviour, NoOpSearchBehaviour
class IterableContainsNotChecker : Checker
open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
abstract class IterableContainsNotCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
abstract class IterableContainsNotOrAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
open class IterableContainsNotSearchBehaviour : IterableContainsInAnyOrderSearchBehaviour, NotSearchBehaviour
object IterableContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory
Module Contents
inline fun <E, T : Iterable<E>> inAnyOrder(builder: Builder<E, T, NoOpSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inAnyOrderOnly(builder: Builder<E, T, InAnyOrderSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrder(builder: Builder<E, T, NoOpSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnly(builder: Builder<E, T, InOrderSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlySearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): <ERROR CLASS>
class LazyRepresentation
interface ListAssertionGroupType : AssertionGroupType
interface LocaleOrderDecider
interface LocaleOrderDeciderOption
interface MapAssertions
object MapAssertionsBuilder : MapAssertions
interface MethodCallFormatter
interface NoOpSearchBehaviour : SearchBehaviour
interface NoOpSearchBehaviour : SearchBehaviour
interface NonThrowingAssertionCollectorForExplanation
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
abstract class NotCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
abstract class NotCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
open class NotCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>
open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>
open class NotCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>
open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class NotOrAtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
abstract class NotOrAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>
open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>
open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>
open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>
interface NotSearchBehaviour : NoOpSearchBehaviour
interface NotSearchBehaviour : InAnyOrderSearchBehaviour
class NullableEintraege<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEintrag<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEntries<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEntries<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEntry<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEntry<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
data class NullableValue<T> : GroupWithNullableEntries<T>
class NullableValue<out T> : GroupWithNullableEntries<T>
class NullableValues<T> : GroupWithNullableEntries<T>
class NullableValues<out T> : GroupWithNullableEntries<T>
data class NullableWert<T> : GroupWithNullableEntries<T>
class NullableWerte<T> : GroupWithNullableEntries<T>
interface ObjectFormatter
interface ObjectFormatterOption
class Objects<out T>
class Order<T, G : Group<T>>
class PlantHasNoSubjectException : RuntimeException
class PleaseUseReplacementException : Exception
class PrefixFailingSummaryAssertion : BulletPointIdentifier
class PrefixFeatureAssertionGroupHeader : BulletPointIdentifier
class PrefixSuccessfulSummaryAssertion : BulletPointIdentifier
interface RawString
class RegexPatterns
class RegexPatterns
interface Reporter
class ReporterBuilder
interface ReporterBuilder
interface ReporterBuilderFinalStep
interface ReporterFactory
interface ReporterOption
interface ReportingAssertionPlant<out T : Any> : AssertionPlant<T>, BaseReportingAssertionPlant<T, AssertionPlant<T>>
interface ReportingAssertionPlantNullable<out T> : AssertionPlantNullable<T>, BaseReportingAssertionPlant<T, AssertionPlantNullable<T>>
object RootAssertionGroupType : AssertionGroupType
interface SearchBehaviourFactory
interface SearchBehaviourFactory
Module Contents
abstract fun <E, T : Iterable<E>> inAnyOrder(builder: Builder<E, T, NoOpSearchBehaviour>): Builder<E, T, InAnyOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inAnyOrderOnly(builder: Builder<E, T, InAnyOrderSearchBehaviour>): Builder<E, T, InAnyOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrder(builder: Builder<E, T, NoOpSearchBehaviour>): Builder<E, T, InOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnly(builder: Builder<E, T, InOrderSearchBehaviour>): Builder<E, T, InOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlySearchBehaviour>): Builder<E, T, InOrderOnlyGroupedSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>
object SingleServiceLoader
data class StringBasedRawString : RawString
interface StringBasedTranslatable : Translatable
interface SummaryAssertionGroupType : DoNotFilterAssertionGroupType
interface TextAssertionFormatterOption
interface ThrowableAssertions
object ThrowableAssertionsBuilder : ThrowableAssertions
interface ThrowableThrown
interface ThrowableThrown
class ThrowableThrownAssertionCreator<TExpected : Throwable> : Creator<TExpected>
interface ThrowableThrownAssertions
object ThrowableThrownAssertionsBuilder : ThrowableThrownAssertions
class ThrowableThrownBuilder : Builder
interface ThrowingAssertionCollectorForExplanation
interface Translatable
class TranslatableAsAbsentThrowableMessageProvider : AbsentThrowableMessageProvider
data class TranslatableBasedRawString : RawString
class TranslatableWithArgs : Translatable
interface TranslationSupplier
interface Translator
interface TranslatorOption
class TypeTransformer<T : Any, TSub : Any>
class Untranslatable : Translatable
class UsingDefaultTranslator : ArgumentsSupportingTranslator
data class Value<T : Any> : GroupWithoutNullableEntries<T>
class Value<out T : Any> : GroupWithoutNullableEntries<T>
class Values<T : Any> : GroupWithoutNullableEntries<T>
class Values<out T : Any> : GroupWithoutNullableEntries<T>
class Values<out T>
object WarningAssertionGroupType : ExplanatoryAssertionGroupType
data class Wert<T : Any> : GroupWithoutNullableEntries<T>
class Werte<T : Any> : GroupWithoutNullableEntries<T>
interface WithTimesCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface WithTimesCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
object case
object case
object contain
object contain
object entries
object group
kotlin.Function0
object only
object only
object order
object order
package ch.tutteli.atrium
Module Contents
interface IAtriumFactory
Module Contents
abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subject: T): CheckingAssertionPlant<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun <T : Any> newFeatureAssertionChecker(subjectPlant: AssertionPlant<T>): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade): Reporter
abstract fun newPropertiesBasedTranslationSupplier(): TranslationSupplier
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subject: T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, reporter: Reporter, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker, nullRepresentation: Any): ReportingAssertionPlantNullable<T>
abstract fun <T> newReportingPlantNullable(commonFields: CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, vararg fallbackLocales: Locale): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit
package ch.tutteli.atrium.api.cc.de_CH
Module Contents
object CharSequenceContainsSearchersKt
Module Contents
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> standardUebersetzungVon(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> wert(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> werte(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
class Eintraege<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>
class Eintrag<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>
class NullableEintraege<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEintrag<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
data class NullableWert<T> : GroupWithNullableEntries<T>
class NullableWerte<T> : GroupWithNullableEntries<T>
data class Wert<T : Any> : GroupWithoutNullableEntries<T>
class Werte<T : Any> : GroupWithoutNullableEntries<T>
fun <T : CharSequence, S : SearchBehaviour> AtLeastCheckerOption<T, S>.aberHoechstens(times: Int): ButAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> aberHoechstens(checkerBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, times: Int): CharSequenceContainsButAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.aberHoechstens(times: Int): ButAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> aberHoechstens(checkerBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, times: Int): IterableContainsButAtMostCheckerBuilder<E, T>
fun <E : Any, T : Iterable<E>> Assert<T>.alle(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.alleDerNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E> Assert<Array<E>>.asIterable(): AssertionPlant<Iterable<E>>
fun Assert<ByteArray>.asIterable(): AssertionPlant<Iterable<Byte>>
fun Assert<CharArray>.asIterable(): AssertionPlant<Iterable<Char>>
fun Assert<ShortArray>.asIterable(): AssertionPlant<Iterable<Short>>
fun Assert<IntArray>.asIterable(): AssertionPlant<Iterable<Int>>
fun Assert<LongArray>.asIterable(): AssertionPlant<Iterable<Long>>
fun Assert<FloatArray>.asIterable(): AssertionPlant<Iterable<Float>>
fun Assert<DoubleArray>.asIterable(): AssertionPlant<Iterable<Double>>
fun Assert<BooleanArray>.asIterable(): AssertionPlant<Iterable<Boolean>>
fun <E, T> Assert<T>.asIterable(): <ERROR CLASS>
fun <T : CharSequence> Assert<T>.beginntMit(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.beginntNichtMit(expected: CharSequence): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.eintraege(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintraege(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.eintraege(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintraege(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.eintraege(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintraege(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.eintrag(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintrag(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.eintrag(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintrag(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.eintrag(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintrag(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endetMit(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endetNichtMit(expected: CharSequence): AssertionPlant<T>
val <T : CharSequence> Assert<T>.enthaelt: Builder<T, NoOpSearchBehaviour>
fun <T : CharSequence> Assert<T>.enthaelt(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.enthaelt(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.enthaelt(assertionCreator: Assert<E>.() -> Unit): <ERROR CLASS>
fun <E : Any, T : Iterable<E>> Assert<T>.enthaelt(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
val <T : CharSequence> Assert<T>.enthaeltNicht: NotCheckerOption<T, NotSearchBehaviour>
fun <T : CharSequence> Assert<T>.enthaeltNicht(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.enthaeltNicht(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.enthaeltNichtDieStandardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> enthaeltNullable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltNullableEintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltNullableEintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltNullableWert(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltNullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.enthaeltRegex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.enthaeltStandardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.enthaeltStrikt(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.enthaeltStrikt(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> enthaeltStriktNullable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltStriktNullableEintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltStriktNullableEintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltStriktNullableWert(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltStriktNullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.genau(times: Int): ExactlyCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> genau(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsExactlyCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.genau(times: Int): ExactlyCheckerOption<E, T, S>
fun <E, T : Iterable<E>> genau(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsExactlyCheckerBuilder<E, T>
fun <T : CharSequence> getEnthaelt(plant: Assert<T>): CharSequenceContainsBuilder<T, NoOpSearchBehaviour>
fun <T : CharSequence> getEnthaeltNicht(plant: Assert<T>): CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>
fun <T : CharSequence> getIgnoriereGrossKleinschreibung(builder: CharSequenceContainsBuilder<T, NoOpSearchBehaviour>): CharSequenceContainsBuilder<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> getIgnoriereGrossKleinschreibung(builder: CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>): CharSequenceContainsNotCheckerBuilder<T, IgnoringCaseSearchBehaviour>
fun <E, T : Iterable<E>> getInBeliebigerReihenfolge(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> getInGegebenerReihenfolge(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InOrderSearchBehaviour>
val <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.gruppiert: <ERROR CLASS>
fun <T : Collection<*>> Assert<T>.hatDieGroesse(size: Int): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.hoechstens(times: Int): AtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> hoechstens(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.hoechstens(times: Int): AtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> hoechstens(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtMostCheckerBuilder<E, T>
val <T : CharSequence> Builder<T, NoOpSearchBehaviour>.ignoriereGrossKleinschreibung: Builder<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoriereGrossKleinschreibung: NotCheckerOption<T, IgnoringCaseSearchBehaviour>
fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inBeliebigerReihenfolge: <ERROR CLASS>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inBeliebigerReihenfolge(firstGroup: GroupWithoutNullableEntries<E>, secondGroup: GroupWithoutNullableEntries<E>, vararg otherExpectedGroups: GroupWithoutNullableEntries<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inBeliebigerReihenfolge(firstGroup: GroupWithNullableEntries<E>, secondGroup: GroupWithNullableEntries<E>, vararg otherExpectedGroups: GroupWithNullableEntries<E>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inBeliebigerReihenfolge(firstGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, secondGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, vararg otherExpectedGroups: GroupWithoutNullableEntries<Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inBeliebigerReihenfolge(firstGroup: GroupWithNullableEntries<Assert<E>.() -> Unit>, secondGroup: GroupWithNullableEntries<Assert<E>.() -> Unit>, vararg otherExpectedGroups: GroupWithNullableEntries<Assert<E>.() -> Unit>): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inGegebenerReihenfolge: <ERROR CLASS>
fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContainsBuilder<E, T, InOrderSearchBehaviour>): IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>
val <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedSearchBehaviour>.innerhalb: <ERROR CLASS>
fun <E : Any, T : Iterable<E?>> Assert<T>.irgendEinNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.irgendEiner(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : Any> Assert<T>.ist(expected: T): AssertionPlant<T>
fun <T> AssertionPlantNullable<T>.ist(null: Nothing?): Unit
inline fun <reified TSub : Any> Assert<Any>.istEin(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun Assert<Boolean>.istFalse(): AssertionPlant<Boolean>
fun <T : BigDecimal> Assert<T>.istGleichInklusiveScale(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.istGroesserAls(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.istGroesserOderGleich(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.istKleinerAls(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.istKleinerOderGleich(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.istLeer(): AssertionPlant<T>
fun Assert<Float>.istMitFehlerToleranz(expected: Float, tolerance: Float): AssertionPlant<Float>
fun Assert<Double>.istMitFehlerToleranz(expected: Double, tolerance: Double): AssertionPlant<Double>
fun <T : BigDecimal> Assert<T>.istMitFehlerToleranz(expected: T, tolerance: T): AssertionPlant<T>
fun <T : Any> Assert<T>.istNicht(expected: T): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.istNichtGleichInklusiveScale(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.istNichtLeer(): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.istNichtNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
inline fun <reified T : Any> AssertionPlantNullable<T?>.istNichtNullAber(expected: T): Unit
fun <T : BigDecimal> Assert<T>.istNichtNumerischGleichWie(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.istNichtSelbeInstanzWie(expected: T): AssertionPlant<T>
fun <T> AssertionPlantNullable<T>.istNull(): Unit
fun <T : BigDecimal> Assert<T>.istNumerischGleichWie(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.istSelbeInstanzWie(expected: T): AssertionPlant<T>
fun Assert<Boolean>.istTrue(): AssertionPlant<Boolean>
fun <E : Any, T : Iterable<E>> Assert<T>.keiner(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.keinerDerNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
fun <T : Throwable> Assert<T>.messageEnthaelt(expected: Any, vararg otherExpected: Any): Unit
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.nichtOderHoechstens(times: Int): NotOrAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> nichtOderHoechstens(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsNotOrAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.nichtOderHoechstens(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> nichtOderHoechstens(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsNotOrAtMostCheckerBuilder<E, T>
fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintraege(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintraege(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintraege(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintrag(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintrag(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintrag(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableWert(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableWert(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableWert(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, InAnyOrderSearchBehaviour>.nur: <ERROR CLASS>
val <E, T : Iterable<E>> Builder<E, T, InOrderSearchBehaviour>.nur: <ERROR CLASS>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.objekt(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekt(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.objekt(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekt(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.objekt(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekt(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.objekte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekte(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.objekte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekte(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.objekte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekte(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T, R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T, R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T, T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.standardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.standardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
val <T : Any> AssertionPlant<T>.und: AssertionPlant<T>
infix fun <T : Any> AssertionPlant<T>.und(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.wert(expected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.wert(expected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.wert(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> wert(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.wert(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> wert(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.wert(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> wert(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.werte(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.werte(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.werte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> werte(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.werte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> werte(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.werte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> werte(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
inline fun <reified TExpected : Throwable> Builder.wirft(): Unit
inline fun <reified TExpected : Throwable> Builder.wirft(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.zumindest(times: Int): AtLeastCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> zumindest(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtLeastCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.zumindest(times: Int): AtLeastCheckerOption<E, T, S>
fun <E, T : Iterable<E>> zumindest(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtLeastCheckerBuilder<E, T>
package ch.tutteli.atrium.api.cc.de_CH.assertions.charsequence.contains.builders
Module Contents
open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
package ch.tutteli.atrium.api.cc.de_CH.assertions.iterable.contains.builders
Module Contents
open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
package ch.tutteli.atrium.api.cc.de_CH.creating.charsequence.contains.builders
Module Contents
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
package ch.tutteli.atrium.api.cc.de_CH.creating.iterable.contains.builders
Module Contents
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
package ch.tutteli.atrium.api.cc.en_GB
Module Contents
class Entries<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>
class Entry<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>
class NullableEntries<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEntry<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
data class NullableValue<T> : GroupWithNullableEntries<T>
class NullableValues<T> : GroupWithNullableEntries<T>
data class Value<T : Any> : GroupWithoutNullableEntries<T>
class Values<T : Any> : GroupWithoutNullableEntries<T>
fun <E : Any, T : Iterable<E>> Assert<T>.all(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.allOfNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
val <T : Any> AssertionPlant<T>.and: AssertionPlant<T>
infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.any(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.anyOfNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E> Assert<Array<E>>.asIterable(): AssertionPlant<Iterable<E>>
fun Assert<ByteArray>.asIterable(): AssertionPlant<Iterable<Byte>>
fun Assert<CharArray>.asIterable(): AssertionPlant<Iterable<Char>>
fun Assert<ShortArray>.asIterable(): AssertionPlant<Iterable<Short>>
fun Assert<IntArray>.asIterable(): AssertionPlant<Iterable<Int>>
fun Assert<LongArray>.asIterable(): AssertionPlant<Iterable<Long>>
fun Assert<FloatArray>.asIterable(): AssertionPlant<Iterable<Float>>
fun Assert<DoubleArray>.asIterable(): AssertionPlant<Iterable<Double>>
fun Assert<BooleanArray>.asIterable(): AssertionPlant<Iterable<Boolean>>
fun <E, T> Assert<T>.asIterable(): <ERROR CLASS>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
fun <T : CharSequence, S : SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
val <T : CharSequence> Assert<T>.contains: Builder<T, NoOpSearchBehaviour>
fun <T : CharSequence> Assert<T>.contains(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.contains(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.contains(assertionCreator: Assert<E>.() -> Unit): <ERROR CLASS>
fun <E : Any, T : Iterable<E>> Assert<T>.contains(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
val <T : CharSequence> Assert<T>.containsNot: NotCheckerOption<T, NotSearchBehaviour>
fun <T : CharSequence> Assert<T>.containsNot(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.containsNot(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsNullableEntries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsNullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsNullableValue(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsNullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsRegex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictlyNullableEntries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictlyNullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsStrictlyNullableValue(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsStrictlyNullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
val <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.grouped: <ERROR CLASS>
fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
val <T : CharSequence> Builder<T, NoOpSearchBehaviour>.ignoringCase: Builder<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoringCase: NotCheckerOption<T, IgnoringCaseSearchBehaviour>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: GroupWithoutNullableEntries<E>, secondGroup: GroupWithoutNullableEntries<E>, vararg otherExpectedGroups: GroupWithoutNullableEntries<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: GroupWithNullableEntries<E>, secondGroup: GroupWithNullableEntries<E>, vararg otherExpectedGroups: GroupWithNullableEntries<E>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, secondGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, vararg otherExpectedGroups: GroupWithoutNullableEntries<Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: GroupWithNullableEntries<Assert<E>.() -> Unit>, secondGroup: GroupWithNullableEntries<Assert<E>.() -> Unit>, vararg otherExpectedGroups: GroupWithNullableEntries<Assert<E>.() -> Unit>): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inAnyOrder: <ERROR CLASS>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inOrder: <ERROR CLASS>
inline fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> Assert<T>.isEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.isNotEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isNotSameAs(expected: T): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isSameAs(expected: T): AssertionPlant<T>
fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
fun <T : Throwable> Assert<T>.messageContains(expected: Any, vararg otherExpected: Any): Unit
fun <E : Any, T : Iterable<E>> Assert<T>.none(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.noneOfNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
inline fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNullBut(expected: T): Unit
fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEntries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEntries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEntries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, InAnyOrderSearchBehaviour>.only: <ERROR CLASS>
val <E, T : Iterable<E>> Builder<E, T, InOrderSearchBehaviour>.only: <ERROR CLASS>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
fun <T> AssertionPlantNullable<T>.toBe(null: Nothing?): Unit
fun Assert<Float>.toBeWithErrorTolerance(expected: Float, tolerance: Float): AssertionPlant<Float>
fun Assert<Double>.toBeWithErrorTolerance(expected: Double, tolerance: Double): AssertionPlant<Double>
fun Assert<BigDecimal>.toBeWithErrorTolerance(expected: BigDecimal, tolerance: BigDecimal): AssertionPlant<BigDecimal>
inline fun <reified TExpected : Throwable> Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedSearchBehaviour>.within: <ERROR CLASS>
package ch.tutteli.atrium.api.cc.en_GB.creating.charsequence.contains.builders
Module Contents
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
package ch.tutteli.atrium.api.cc.en_GB.creating.iterable.contains.builders
Module Contents
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
package ch.tutteli.atrium.api.cc.en_UK
Module Contents
object CharSequenceContainsSearchersKt
Module Contents
fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> values(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
val <T : Any> AssertionPlant<T>.and: AssertionPlant<T>
infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> atLeast(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtLeastCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atLeast(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtLeastCheckerBuilder<E, T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> atMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtMostCheckerBuilder<E, T>
fun <T : CharSequence, S : SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> butAtMost(checkerBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, times: Int): CharSequenceContainsButAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> butAtMost(checkerBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, times: Int): IterableContainsButAtMostCheckerBuilder<E, T>
val <T : CharSequence> Assert<T>.contains: Builder<T, NoOpSearchBehaviour>
fun <T : CharSequence> Assert<T>.contains(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.contains(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.contains(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsDefaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
val <T : CharSequence> Assert<T>.containsNot: NotCheckerOption<T, NotSearchBehaviour>
fun <T : CharSequence> Assert<T>.containsNot(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsNot(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsNotDefaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsNullable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsRegex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsStrictly(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsStrictlyNulllable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.defaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.defaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entries(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entries(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entries(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> exactly(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsExactlyCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
fun <E, T : Iterable<E>> exactly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsExactlyCheckerBuilder<E, T>
fun <T : CharSequence> getContains(plant: Assert<T>): CharSequenceContainsBuilder<T, NoOpSearchBehaviour>
fun <T : CharSequence> getContainsNot(plant: Assert<T>): CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>
fun <T : CharSequence> getIgnoringCase(builder: CharSequenceContainsBuilder<T, NoOpSearchBehaviour>): CharSequenceContainsBuilder<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> getIgnoringCase(builder: CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>): CharSequenceContainsNotCheckerBuilder<T, IgnoringCaseSearchBehaviour>
fun <E, T : Iterable<E>> getInAnyOrder(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> getInOrder(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InOrderSearchBehaviour>
fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
val <T : CharSequence> Builder<T, NoOpSearchBehaviour>.ignoringCase: Builder<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoringCase: NotCheckerOption<T, IgnoringCaseSearchBehaviour>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inAnyOrder: <ERROR CLASS>
fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inOrder: <ERROR CLASS>
fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContainsBuilder<E, T, InOrderSearchBehaviour>): IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>
inline fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> Assert<T>.isEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
fun Assert<Boolean>.isFalse(): AssertionPlant<Boolean>
fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.isNotEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.isNotNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isNotSame(expected: T): AssertionPlant<T>
fun <T> AssertionPlantNullable<T>.isNull(): Unit
fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isSame(expected: T): AssertionPlant<T>
fun Assert<Boolean>.isTrue(): AssertionPlant<Boolean>
fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> notOrAtMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsNotOrAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> notOrAtMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsNotOrAtMostCheckerBuilder<E, T>
fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValue(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValue(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableValue(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValues(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValues(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableValues(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.objects(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objects(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.objects(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objects(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.objects(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objects(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, InAnyOrderSearchBehaviour>.only: <ERROR CLASS>
val <E, T : Iterable<E>> Builder<E, T, InOrderSearchBehaviour>.only: <ERROR CLASS>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
fun Assert<Float>.toBeWithErrorTolerance(expected: Float, tolerance: Float): AssertionPlant<Float>
fun Assert<Double>.toBeWithErrorTolerance(expected: Double, tolerance: Double): AssertionPlant<Double>
fun Assert<BigDecimal>.toBeWithErrorTolerance(expected: BigDecimal, tolerance: BigDecimal): AssertionPlant<BigDecimal>
inline fun <reified TExpected : Throwable> Builder.toThrow(): Unit
inline fun <reified TExpected : Throwable> Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> values(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> values(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> values(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
package ch.tutteli.atrium.api.cc.en_UK.assertions.charsequence.contains.builders
Module Contents
open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
package ch.tutteli.atrium.api.cc.en_UK.assertions.iterable.contains.builders
Module Contents
open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
package ch.tutteli.atrium.api.cc.en_UK.creating.charsequence.contains.builders
Module Contents
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class AtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class NotCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>
package ch.tutteli.atrium.api.cc.en_UK.creating.iterable.contains.builders
Module Contents
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>
package ch.tutteli.atrium.api.cc.infix.en_GB
Module Contents
class Entries<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>
class Entry<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>
class NullableEntries<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEntry<in T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableValue<out T> : GroupWithNullableEntries<T>
class NullableValues<out T> : GroupWithNullableEntries<T>
class Order<T, G : Group<T>>
class RegexPatterns
class Value<out T : Any> : GroupWithoutNullableEntries<T>
class Values<out T : Any> : GroupWithoutNullableEntries<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.all(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.all(nullableEntry: NullableEntry<E>): AssertionPlant<T>
infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderSearchBehaviour>.and(only: only): <ERROR CLASS>
infix fun <E : Any, T : Iterable<E>> Assert<T>.any(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.any(nullableEntry: NullableEntry<E>): AssertionPlant<T>
fun <E> Assert<Array<E>>.asIterable(): AssertionPlant<Iterable<E>>
fun Assert<ByteArray>.asIterable(): AssertionPlant<Iterable<Byte>>
fun Assert<CharArray>.asIterable(): AssertionPlant<Iterable<Char>>
fun Assert<ShortArray>.asIterable(): AssertionPlant<Iterable<Short>>
fun Assert<IntArray>.asIterable(): AssertionPlant<Iterable<Int>>
fun Assert<LongArray>.asIterable(): AssertionPlant<Iterable<Long>>
fun Assert<FloatArray>.asIterable(): AssertionPlant<Iterable<Float>>
fun Assert<DoubleArray>.asIterable(): AssertionPlant<Iterable<Double>>
fun Assert<BooleanArray>.asIterable(): AssertionPlant<Iterable<Boolean>>
fun <E, T> Assert<T>.asIterable(): <ERROR CLASS>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderSearchBehaviour>.but(only: only): <ERROR CLASS>
infix fun <T : CharSequence, S : SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
infix fun <T : CharSequence> Assert<T>.contains(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(expected: E): <ERROR CLASS>
infix fun <E, T : Iterable<E>> Assert<T>.contains(expected: NullableValue<E>): <ERROR CLASS>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.contains(nullableEntry: NullableEntry<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(entries: Entries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.contains(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(values: Values<Any>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsNot(expected: E): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsNot(values: Values<E>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsRegex(pattern: String): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(expected: NullableValue<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictly(nullableEntry: NullableEntry<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(entries: Entries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictly(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.grouped(entries: entries): <ERROR CLASS>
infix fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
infix fun <T : CharSequence> Builder<T, NoOpSearchBehaviour>.ignoring(case: case): Builder<T, IgnoringCaseSearchBehaviour>
infix fun <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoring(case: case): NotCheckerOption<T, IgnoringCaseSearchBehaviour>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<E, GroupWithoutNullableEntries<E>>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<E, GroupWithNullableEntries<E>>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<Assert<E>.() -> Unit, GroupWithoutNullableEntries<Assert<E>.() -> Unit>>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<Assert<E>.() -> Unit, GroupWithNullableEntries<Assert<E>.() -> Unit>>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inAny(order: order): <ERROR CLASS>
infix fun <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inGiven(order: order): <ERROR CLASS>
inline infix fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
infix fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isNotSameAs(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isSameAs(expected: T): AssertionPlant<T>
infix fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
infix fun <T : Throwable> Assert<T>.messageContains(expected: Any): Unit
infix fun <T : Throwable> Assert<T>.messageContains(values: Values<Any>): Unit
infix fun <E : Any, T : Iterable<E>> Assert<T>.none(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.none(nullableEntry: NullableEntry<E>): AssertionPlant<T>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
infix fun <T : CharSequence> Assert<T>.notTo(contain: contain): NotCheckerOption<T, NotSearchBehaviour>
infix fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.notToBe(onlyEmptyAllowed: Empty): AssertionPlant<T>
inline infix fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
inline infix fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNullBut(expected: T): Unit
infix fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
infix fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(entries: Entries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.the(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(values: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(entries: Entries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.the(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(entries: Entries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.the(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.to(contain: contain): Builder<T, NoOpSearchBehaviour>
infix fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
infix fun <T> AssertionPlantNullable<T>.toBe(null: Nothing?): Unit
infix fun <T : CharSequence> Assert<T>.toBe(Empty: Empty): AssertionPlant<T>
inline infix fun <reified TExpected : Throwable> Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedSearchBehaviour>.within(group: group): <ERROR CLASS>
package ch.tutteli.atrium.api.cc.infix.en_GB.creating.charsequence.contains.builders
Module Contents
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
package ch.tutteli.atrium.api.cc.infix.en_GB.creating.iterable.contains.builders
Module Contents
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
package ch.tutteli.atrium.api.cc.infix.en_GB.keywords
package ch.tutteli.atrium.api.cc.infix.en_UK
Module Contents
object CharSequenceContainsSearchersKt
Module Contents
fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>
class DefaultTranslationsOf
object Empty
class Entries<in T : Any, out A : (Assert<T>) -> Unit>
class Objects<out T>
class RegexPatterns
class Values<out T>
infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> atLeast(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtLeastCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atLeast(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtLeastCheckerBuilder<E, T>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> atMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtMostCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtMostCheckerBuilder<E, T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderSearchBehaviour>.but(only: only): <ERROR CLASS>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderSearchBehaviour>.but(only: only): <ERROR CLASS>
infix fun <T : CharSequence, S : SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> butAtMost(checkerBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, times: Int): CharSequenceContainsButAtMostCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> butAtMost(checkerBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, times: Int): IterableContainsButAtMostCheckerBuilder<E, T>
object case
object contain
infix fun <T : CharSequence> Assert<T>.contains(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(defaultTranslationOf: DefaultTranslationsOf): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(expected: E): <ERROR CLASS>
infix fun <E, T : Iterable<E>> Assert<T>.contains(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsDefaultTranslationOf(translatable: Translatable): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(defaultTranslationsOf: DefaultTranslationsOf): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(objects: Objects<E>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsNullable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsNullable(plant: Assert<T>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsRegex(pattern: String): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsStrictlyNullable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsStrictlyNullable(plant: Assert<T>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.defaultTranslationOf(translatable: Translatable): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.defaultTranslationOf(translatable: Translatable): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> exactly(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsExactlyCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
fun <E, T : Iterable<E>> exactly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsExactlyCheckerBuilder<E, T>
infix fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
infix fun <T : CharSequence> Builder<T, NoOpSearchBehaviour>.ignoring(case: case): Builder<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> ignoring(builder: CharSequenceContainsBuilder<T, NoOpSearchBehaviour>, case: case): CharSequenceContainsBuilder<T, IgnoringCaseSearchBehaviour>
infix fun <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoring(case: case): NotCheckerOption<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>.ignoring(case: case): CharSequenceContainsNotCheckerBuilder<T, IgnoringCaseSearchBehaviour>
infix fun <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inAny(order: order): <ERROR CLASS>
fun <E, T : Iterable<E>> inAny(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>, order: order): IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, only: only): IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>
infix fun <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inGiven(order: order): <ERROR CLASS>
fun <E, T : Iterable<E>> inGiven(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>, order: order): IterableContainsBuilder<E, T, InOrderSearchBehaviour>
fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContainsBuilder<E, T, InOrderSearchBehaviour>, only: only): IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>
inline infix fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
infix fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isNotSame(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isSame(expected: T): AssertionPlant<T>
infix fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> notOrAtMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsNotOrAtMostCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> notOrAtMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsNotOrAtMostCheckerBuilder<E, T>
infix fun <T : CharSequence> Assert<T>.notTo(contain: contain): NotCheckerOption<T, NotSearchBehaviour>
infix fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.notToBe(onlyEmptyAllowed: Empty): AssertionPlant<T>
inline infix fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(builder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(builder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(builder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(builder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
object only
object order
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
infix fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.the(translatables: DefaultTranslationsOf): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.the(translatables: DefaultTranslationsOf): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(objects: Objects<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> the(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(objects: Objects<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(objects: Objects<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.to(contain: contain): Builder<T, NoOpSearchBehaviour>
infix fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
infix fun <T> AssertionPlantNullable<T>.toBe(null: Nothing?): Unit
infix fun <T : CharSequence> Assert<T>.toBe(Empty: Empty): AssertionPlant<T>
inline fun <reified TExpected : Throwable> Builder.toThrow(): Unit
inline infix fun <reified TExpected : Throwable> Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
package ch.tutteli.atrium.api.cc.infix.en_UK.assertions.charsequence.contains.builders
Module Contents
open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
fun nameContainsNotValuesFun(): String
package ch.tutteli.atrium.api.cc.infix.en_UK.assertions.iterable.contains.builders
Module Contents
open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
package ch.tutteli.atrium.api.cc.infix.en_UK.creating.charsequence.contains.builders
Module Contents
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class AtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class NotCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>
package ch.tutteli.atrium.api.cc.infix.en_UK.creating.iterable.contains.builders
Module Contents
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>
package ch.tutteli.atrium.assertions
Module Contents
interface Assertion
interface AssertionGroup : Assertion
interface AssertionGroupType : BulletPointIdentifier
data class BasicAssertionGroup : AssertionGroup
class BasicDescriptiveAssertion : DescriptiveAssertion
class BasicExplanatoryAssertion : ExplanatoryAssertion
interface BulletPointIdentifier
object DefaultExplanatoryAssertionGroupType : ExplanatoryAssertionGroupType
object DefaultFeatureAssertionGroupType : FeatureAssertionGroupType
object DefaultIndentAssertionGroupType : IndentAssertionGroupType
object DefaultListAssertionGroupType : ListAssertionGroupType
object DefaultSummaryAssertionGroupType : SummaryAssertionGroupType
enum class DescriptionAnyAssertion : StringBasedTranslatable
enum class DescriptionBasic : StringBasedTranslatable
enum class DescriptionBigDecimalAssertion : StringBasedTranslatable
enum class DescriptionCharSequenceAssertion : StringBasedTranslatable
enum class DescriptionCollectionAssertion : StringBasedTranslatable
enum class DescriptionComparableAssertion : StringBasedTranslatable
enum class DescriptionFloatingPointAssertion : StringBasedTranslatable
enum class DescriptionIterableAssertion : StringBasedTranslatable
enum class DescriptionThrowableAssertion : StringBasedTranslatable
enum class DescriptionTypeTransformationAssertion : StringBasedTranslatable
interface DescriptiveAssertion : Assertion
interface DoNotFilterAssertionGroupType : AssertionGroupType
open class EmptyNameAndRepresentationAssertionGroup : AssertionGroup
interface ExplanatoryAssertion : Assertion
class ExplanatoryAssertionGroup : EmptyNameAndRepresentationAssertionGroup
interface ExplanatoryAssertionGroupType : DoNotFilterAssertionGroupType
interface FeatureAssertionGroupType : AssertionGroupType
class IndentAssertionGroup : EmptyNameAndRepresentationAssertionGroup
interface IndentAssertionGroupType : AssertionGroupType
class InvisibleAssertionGroup : EmptyNameAndRepresentationAssertionGroup
object InvisibleAssertionGroupType : AssertionGroupType
interface ListAssertionGroupType : AssertionGroupType
class PrefixFailingSummaryAssertion : BulletPointIdentifier
class PrefixFeatureAssertionGroupHeader : BulletPointIdentifier
class PrefixSuccessfulSummaryAssertion : BulletPointIdentifier
object RootAssertionGroupType : AssertionGroupType
interface SummaryAssertionGroupType : DoNotFilterAssertionGroupType
object WarningAssertionGroupType : ExplanatoryAssertionGroupType
fun <T : CharSequence> _containsBuilder(plant: AssertionPlant<T>): <ERROR CLASS>
fun <T : CharSequence> _containsNotBuilder(plant: AssertionPlant<T>): <ERROR CLASS>
fun <T : Any, TSub : T> _downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> _endsNotWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : CharSequence> _endsWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : Collection<*>> _hasSize(plant: AssertionPlant<T>, size: Int): Assertion
inline fun <reified TSub : Any> _isA(plant: AssertionPlant<Any>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> _isEmpty(plant: AssertionPlant<T>): Assertion
fun <T : BigDecimal> _isEqualIncludingScale(plant: AssertionPlant<T>, expected: T, nameOfIsNumericallyEqualTo: String): Assertion
fun <T : Comparable<T>> _isGreaterOrEquals(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : Comparable<T>> _isGreaterThan(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : Comparable<T>> _isLessOrEquals(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : Comparable<T>> _isLessThan(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : CharSequence> _isNotEmpty(plant: AssertionPlant<T>): Assertion
fun <T : BigDecimal> _isNotEqualIncludingScale(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <reified T : Any> _isNotNull(plant: AssertionPlantNullable<T?>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): Unit
fun <T : BigDecimal> _isNotNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : Any> _isNotSame(plant: AssertionPlant<T>, expected: T): Assertion
fun <T> _isNull(plant: AssertionPlantNullable<T>): Assertion
fun <T : BigDecimal> _isNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : Any> _isSame(plant: AssertionPlant<T>, expected: T): Assertion
fun <T : Any, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: () -> TReturnValue): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: () -> TReturnValue, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1) -> TReturnValue, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1) -> TReturnValue, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2) -> TReturnValue, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2) -> TReturnValue, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4, T5) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4, T5) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any> _notToBe(plant: AssertionPlant<T>, expected: T): Assertion
fun <T : Any, TProperty : Any> _property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> _property(plant: AssertionPlant<T>, property: KProperty0<TProperty>, assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction0<TReturnValue>): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction0<TReturnValue>, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction1<T1, TReturnValue>, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction1<T1, TReturnValue>, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : CharSequence> _startsNotWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : CharSequence> _startsWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : Any> _toBe(plant: AssertionPlant<T>, expected: T): Assertion
fun _toBeWithErrorTolerance(plant: AssertionPlant<Float>, expected: Float, tolerance: Float): Assertion
fun _toBeWithErrorTolerance(plant: AssertionPlant<Double>, expected: Double, tolerance: Double): Assertion
fun <T : BigDecimal> _toBeWithErrorTolerance(plant: AssertionPlant<T>, expected: T, tolerance: T): Assertion
fun <TExpected : Throwable> _toThrow(throwableThrownBuilder: <ERROR CLASS>, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit
fun <T : Any, TSub : Any> _typeTransformation(description: Translatable, representation: Any, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, warningTransformationFailed: Translatable, canBeTransformed: (T) -> Boolean, transform: (T) -> TSub): Unit
package ch.tutteli.atrium.assertions.any.typetransformation
package ch.tutteli.atrium.assertions.basic.contains
package ch.tutteli.atrium.assertions.basic.contains.builders
Module Contents
abstract class ContainsBuilder<out T : Any, out S : SearchBehaviour> : Builder<T, S>
interface ContainsCheckerBuilder<out T : Any, out S : SearchBehaviour, out C : Checker, out B : Builder<T, S>> : CheckerOption<T, S, C, B>
fun validateAtMost(times: Int, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String): Unit
fun validateButAtMost(atLeastTimes: Int, butAtMostTimes: Int, atLeastButAtMostCall: (Int, Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String): Unit
package ch.tutteli.atrium.assertions.basic.contains.checkers
package ch.tutteli.atrium.assertions.basic.contains.creators
package ch.tutteli.atrium.assertions.builders
Module Contents
interface AssertionBuilder
interface AssertionBuilderFinalStep<T : Assertion>
interface AssertionGroupDescriptionAndEmptyRepresentationOption<out T : AssertionGroupType, R>
interface AssertionGroupDescriptionAndRepresentationOption<out T : AssertionGroupType, R>
interface AssertionsOption<out T : AssertionGroupType, R>
Module Contents
fun <T : AssertionGroupType> asFactoryWithDefaultFinalStep(): (T, Translatable, Any) -> AssertionsOption<T, BasicAssertionGroupFinalStep>
fun <T : AssertionGroupType, R> create(groupType: T, description: Translatable, representation: Any, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
abstract val description: Translatable
abstract val groupType: T
abstract val representation: Any
open fun withAssertion(assertion: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion, assertion3: Assertion): R
abstract fun withAssertions(assertions: List<Assertion>): R
fun <T : AssertionGroupType> withDefaultFinalStepAndEmptyDescriptionAndRepresentation(groupType: T): AssertionsOption<T, BasicAssertionGroupFinalStep>
fun <T : AssertionGroupType, R> withEmptyDescriptionAndRepresentation(groupType: T, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
interface BasicAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>
typealias DefaultAssertionGroupBuilderOptions<T> = AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, BasicAssertionGroupFinalStep>>
interface DescriptiveAssertionFinalStep : AssertionBuilderFinalStep<DescriptiveAssertion>
interface DescriptiveAssertionHoldsOption
interface DescriptiveLikeAssertionDescriptionOption<R>
interface ExplanatoryAssertionExplanationOption
interface ExplanatoryAssertionFinalStep : AssertionBuilderFinalStep<ExplanatoryAssertion>
interface ExplanatoryAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>
interface ExplanatoryAssertionGroupTypeOption
val assertionBuilder: AssertionBuilder
val AssertionBuilder.invisibleGroup: AssertionsOption<InvisibleAssertionGroupType, BasicAssertionGroupFinalStep>
val AssertionBuilder.root: DefaultAssertionGroupBuilderOptions<RootAssertionGroupType>
fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertion(translatable: Translatable): ExplanatoryAssertionGroupFinalStep
fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertions(translatable: Translatable, arg: Any, vararg otherArgs: Any): ExplanatoryAssertionGroupFinalStep
package ch.tutteli.atrium.assertions.charsequence.contains
package ch.tutteli.atrium.assertions.charsequence.contains.builders
Module Contents
abstract class CharSequenceContainsAtLeastCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
class CharSequenceContainsBuilder<out T : CharSequence, out S : SearchBehaviour> : ContainsBuilder<T, S>, Builder<T, S>
abstract class CharSequenceContainsButAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
Module Contents
CharSequenceContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilderBase<T, S>, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: Builder<T, S>
val times: Int
interface CharSequenceContainsCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ContainsCheckerBuilder<T, S, Checker, Builder<T, S>>, CheckerOption<T, S>
abstract class CharSequenceContainsExactlyCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsNotCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsNotOrAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
package ch.tutteli.atrium.assertions.charsequence.contains.checkers
package ch.tutteli.atrium.assertions.charsequence.contains.creators
Module Contents
class CharSequenceContainsAssertionCreator<T : CharSequence, S : SearchBehaviour> : ContainsObjectsAssertionCreator<T, Any, S, Checker>, Creator<T, Any>
fun <T : CharSequence> _containsDefaultTranslationOf(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsNoOpSearchBehaviour>, expected: Translatable, otherExpected: Array<out Translatable>): AssertionGroup
fun <T : CharSequence> _containsDefaultTranslationOfIgnoringCase(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsIgnoringCaseSearchBehaviour>, expected: Translatable, otherExpected: Array<out Translatable>): AssertionGroup
fun <T : CharSequence> _containsRegex(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsNoOpSearchBehaviour>, expected: String, otherExpected: Array<out String>): AssertionGroup
fun <T : CharSequence> _containsRegexIgnoringCase(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsIgnoringCaseSearchBehaviour>, expected: String, otherExpected: Array<out String>): AssertionGroup
fun <T : CharSequence> _containsValues(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsNoOpSearchBehaviour>, expected: Any, otherExpected: Array<out Any>): AssertionGroup
fun <T : CharSequence> _containsValuesIgnoringCase(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsIgnoringCaseSearchBehaviour>, expected: Any, otherExpected: Array<out Any>): AssertionGroup
package ch.tutteli.atrium.assertions.charsequence.contains.searchbehaviours
package ch.tutteli.atrium.assertions.charsequence.contains.searchers
package ch.tutteli.atrium.assertions.iterable.contains
package ch.tutteli.atrium.assertions.iterable.contains.builders
Module Contents
abstract class IterableContainsAtLeastCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
abstract class IterableContainsAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
open class IterableContainsBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : ContainsBuilder<T, S>, Builder<E, T, S>
abstract class IterableContainsButAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
Module Contents
IterableContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilderBase<E, T, S>, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int
interface IterableContainsCheckerBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : ContainsCheckerBuilder<T, S, Checker, Builder<E, T, S>>, CheckerOption<E, T, S>
abstract class IterableContainsExactlyCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
class IterableContainsNoOpCheckerBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
abstract class IterableContainsNotCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
abstract class IterableContainsNotOrAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
package ch.tutteli.atrium.assertions.iterable.contains.checkers
package ch.tutteli.atrium.assertions.iterable.contains.creators
Module Contents
open class IterableContainsInAnyOrderEntriesAssertionCreator<E : Any, T : Iterable<E?>> : ContainsAssertionCreator<T, AssertionPlant<E>.() -> Unit, Checker>, Creator<T, AssertionPlant<E>.() -> Unit>
class IterableContainsInAnyOrderObjectsAssertionCreator<S, T : Iterable<S>> : ContainsObjectsAssertionCreator<T, S, IterableContainsInAnyOrderSearchBehaviour, Checker>, Creator<T, S>
abstract class IterableContainsInAnyOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : Creator<T, SC>
class IterableContainsInAnyOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, AssertionPlant<E>.() -> Unit>
class IterableContainsInAnyOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, E>
abstract class IterableContainsInOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : Creator<T, SC>
class IterableContainsInOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, AssertionPlant<E>.() -> Unit>
class IterableContainsInOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, E>
fun <E : Any, T : Iterable<E>> _containsEntriesInAnyOrder(checker: IterableContainsCheckerBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>, assertionCreator: AssertionPlant<E>.() -> Unit, otherAssertionCreators: Array<AssertionPlant<E>.() -> Unit>): Assertion
fun <E : Any, T : Iterable<E>> _containsEntriesInAnyOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInAnyOrderOnlySearchBehaviour>, assertionCreator: AssertionPlant<E>.() -> Unit, otherAssertionCreators: Array<AssertionPlant<E>.() -> Unit>): Assertion
fun <E : Any, T : Iterable<E>> _containsEntriesInOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInOrderOnlySearchBehaviour>, assertionCreator: AssertionPlant<E>.() -> Unit, otherAssertionCreators: Array<AssertionPlant<E>.() -> Unit>): Assertion
fun <E, T : Iterable<E>> _containsObjectsInAnyOrder(checker: IterableContainsCheckerBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>, expected: E, otherExpected: Array<out E>): Assertion
fun <E, T : Iterable<E>> _containsObjectsInAnyOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInAnyOrderOnlySearchBehaviour>, expected: E, otherExpected: Array<out E>): Assertion
fun <E, T : Iterable<E>> _containsObjectsInOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInOrderOnlySearchBehaviour>, expected: E, otherExpected: Array<out E>): Assertion
package ch.tutteli.atrium.assertions.iterable.contains.searchbehaviours
Module Contents
open class IterableContainsInAnyOrderOnlySearchBehaviour : SearchBehaviour, InAnyOrderOnlySearchBehaviour
open class IterableContainsInAnyOrderSearchBehaviour : SearchBehaviour, InAnyOrderSearchBehaviour
open class IterableContainsInOrderOnlySearchBehaviour : SearchBehaviour, InOrderOnlySearchBehaviour
open class IterableContainsInOrderSearchBehaviour : SearchBehaviour, InOrderSearchBehaviour
open class IterableContainsNoOpSearchBehaviour : SearchBehaviour, NoOpSearchBehaviour
open class IterableContainsNotSearchBehaviour : IterableContainsInAnyOrderSearchBehaviour, NotSearchBehaviour
fun <E, T : Iterable<E>> _containsInAnyOrder(containsBuilder: IterableContainsBuilder<E, T, IterableContainsNoOpSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> _containsInAnyOrderOnly(containsBuilder: IterableContainsBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInAnyOrderOnlySearchBehaviour>
fun <E, T : Iterable<E>> _containsInOrder(containsBuilder: IterableContainsBuilder<E, T, IterableContainsNoOpSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInOrderSearchBehaviour>
fun <E, T : Iterable<E>> _containsInOrderOnly(containsBuilder: IterableContainsBuilder<E, T, IterableContainsInOrderSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInOrderOnlySearchBehaviour>
package ch.tutteli.atrium.assertions.throwable.thrown
package ch.tutteli.atrium.assertions.throwable.thrown.builders
package ch.tutteli.atrium.assertions.throwable.thrown.creators
package ch.tutteli.atrium.assertions.throwable.thrown.providers
package ch.tutteli.atrium.checking
package ch.tutteli.atrium.core
Module Contents
interface CoreFactory
Module Contents
abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subjectProvider: () -> T): CheckingAssertionPlant<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun <T : Any> newFeatureAssertionChecker(subjectPlant: AssertionPlant<T>): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade): Reporter
abstract fun newPropertiesBasedTranslationSupplier(): TranslationSupplier
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
abstract fun <T> newReportingPlantNullable(commonFields: CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSummaryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, fallbackLocales: List<Locale>): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit
object SingleServiceLoader
val coreFactory: <ERROR CLASS>
val falseProvider: () -> Boolean
kotlin.Function0
val trueProvider: () -> Boolean
package ch.tutteli.atrium.creating
Module Contents
typealias Assert<T> = AssertionPlant<T>
@DslMarker annotation class AssertMarker
interface AssertionPlant<out T : Any> : BaseAssertionPlant<T, AssertionPlant<T>>
interface AssertionPlantNullable<out T> : BaseAssertionPlant<T, AssertionPlantNullable<T>>
interface AssertionPlantWithCommonFields<out T>
interface BaseAssertionPlant<out T, out A : BaseAssertionPlant<T, A>>
interface BaseReportingAssertionPlant<out T, out A : BaseAssertionPlant<T, A>> : BaseAssertionPlant<T, A>, AssertionPlantWithCommonFields<T>
interface CheckingAssertionPlant<out T : Any> : AssertionPlant<T>
interface CollectingAssertionPlant<out T : Any> : AssertionPlant<T>
class PlantHasNoSubjectException : RuntimeException
interface ReportingAssertionPlant<out T : Any> : AssertionPlant<T>, BaseReportingAssertionPlant<T, AssertionPlant<T>>
interface ReportingAssertionPlantNullable<out T> : AssertionPlantNullable<T>, BaseReportingAssertionPlant<T, AssertionPlantNullable<T>>
package ch.tutteli.atrium.domain.assertions.composers
package ch.tutteli.atrium.domain.builders
package ch.tutteli.atrium.domain.builders.assertions.builders
package ch.tutteli.atrium.domain.builders.creating
Module Contents
object AbsentThrowableMessageProviderFactoryBuilder : AbsentThrowableMessageProviderFactory
object AnyAssertionsBuilder : AnyAssertions
object AnyTypeTransformationAssertionsBuilder : AnyTypeTransformationAssertions
Module Contents
inline fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: FailureHandler<T, TSub>): <ERROR CLASS>
inline val failureHandlers: AnyTypeTransformationFailureHandlerFactoryBuilder
inline fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): <ERROR CLASS>
inline fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): <ERROR CLASS>
inline fun <S : Any, T : Any> transform(parameterObject: ParameterObject<S, T>, noinline canBeTransformed: (S) -> Boolean, noinline transform: (S) -> T, failureHandler: FailureHandler<S, T>): <ERROR CLASS>
object AnyTypeTransformationFailureHandlerFactoryBuilder : FailureHandlerFactory
object BigDecimalAssertionsBuilder : BigDecimalAssertions
object CharSequenceAssertionsBuilder : CharSequenceAssertions
object CharSequenceContainsAssertionsBuilder : CharSequenceContainsAssertions
Module Contents
inline fun <T : CharSequence> defaultTranslationOf(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): <ERROR CLASS>
inline fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): <ERROR CLASS>
inline fun <T : CharSequence> regex(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<String>): <ERROR CLASS>
inline fun <T : CharSequence> regexIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): <ERROR CLASS>
inline val searchBehaviours: CharSequenceContainsSearchBehaviourFactoryBuilder
inline fun <T : CharSequence> values(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Any>): <ERROR CLASS>
inline fun <T : CharSequence> valuesIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Any>): <ERROR CLASS>
object CharSequenceContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory
object CollectionAssertionsBuilder : CollectionAssertions
object ComparableAssertionsBuilder : ComparableAssertions
object FeatureAssertionsBuilder : FeatureAssertions
Module Contents
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
object FloatingPointAssertionsBuilder : FloatingPointAssertions
object IterableAssertionsBuilder : IterableAssertions
object IterableContainsAssertionsBuilder : IterableContainsAssertions
Module Contents
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<AssertionPlant<E>.() -> Unit>>): Assertion
inline val searchBehaviours: IterableContainsSearchBehaviourFactoryBuilder
inline fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInOrderOnly(builder: Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion
object IterableContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory
Module Contents
inline fun <E, T : Iterable<E>> inAnyOrder(builder: Builder<E, T, NoOpSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inAnyOrderOnly(builder: Builder<E, T, InAnyOrderSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrder(builder: Builder<E, T, NoOpSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnly(builder: Builder<E, T, InOrderSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlySearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): <ERROR CLASS>
object MapAssertionsBuilder : MapAssertions
class PleaseUseReplacementException : Exception
object ThrowableAssertionsBuilder : ThrowableAssertions
object ThrowableThrownAssertionsBuilder : ThrowableThrownAssertions
package ch.tutteli.atrium.domain.builders.creating.charsequence.contains.builders
Module Contents
abstract class AtLeastCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
abstract class AtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
abstract class ButAtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
Module Contents
ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<T, S>, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<T, S>
val times: Int
abstract class ExactlyCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
abstract class NotCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
abstract class NotOrAtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface WithTimesCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
package ch.tutteli.atrium.domain.builders.creating.collectors
package ch.tutteli.atrium.domain.builders.creating.iterable.contains.builders
Module Contents
abstract class AtLeastCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class AtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class ButAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
Module Contents
ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<E, T, S>, containsBuilder: Builder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<E, T, S>
val times: Int
abstract class ExactlyCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class NotCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
abstract class NotOrAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface WithTimesCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
package ch.tutteli.atrium.domain.builders.reporting
package ch.tutteli.atrium.domain.builders.utils
Module Contents
interface Group<out T>
interface GroupWithNullableEntries<out T> : Group<T>
interface GroupWithoutNullableEntries<out T : Any> : Group<T>
fun <T> groupsToList(firstGroup: Group<T>, secondGroup: Group<T>, otherGroups: Array<out Group<T>>): List<List<T>>
inline fun <T> nullable(t: T): T?
inline fun <T> nullable(t: KFunction0<T>): KFunction0<T?>
inline fun <T1, R> nullable(t: KFunction1<T1, R>): KFunction1<T1, R?>
inline fun <T1, T2, R> nullable(t: KFunction2<T1, T2, R>): KFunction2<T1, T2, R?>
inline fun <T1, T2, T3, R> nullable(t: KFunction3<T1, T2, T3, R>): KFunction3<T1, T2, T3, R?>
inline fun <T1, T2, T3, T4, R> nullable(t: KFunction4<T1, T2, T3, T4, R>): KFunction4<T1, T2, T3, T4, R?>
inline fun <T1, T2, T3, T4, T5, R> nullable(t: KFunction5<T1, T2, T3, T4, T5, R>): KFunction5<T1, T2, T3, T4, T5, R?>
inline fun <T> nullableContainer(iterable: Iterable<T>): Iterable<T?>
inline fun <T> nullableContainer(arr: Array<out T>): Array<out T?>
inline fun <K, V : Any> nullableKeyMap(map: Map<out K, V>): Map<out K?, V>
inline fun <K : Any, V> nullableValueMap(map: Map<K, V>): Map<K, V?>
inline fun <T : Any> subAssert(noinline assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>.() -> Unit
fun validateAtMost(times: Int, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String): Unit
fun validateButAtMost(atLeastTimes: Int, butAtMostTimes: Int, atLeastButAtMostCall: (Int, Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String): Unit
package ch.tutteli.atrium.domain.creating
Module Contents
interface AnyAssertions
interface BigDecimalAssertions
interface CharSequenceAssertions
interface CollectionAssertions
interface ComparableAssertions
interface FeatureAssertions
Module Contents
abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlant<R>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
interface FloatingPointAssertions
interface IterableAssertions
interface MapAssertions
interface ThrowableAssertions
val anyAssertions: <ERROR CLASS>
val bigDecimalAssertions: <ERROR CLASS>
val charSequenceAssertions: <ERROR CLASS>
val collectionAssertions: <ERROR CLASS>
val comparableAssertions: <ERROR CLASS>
val featureAssertions: <ERROR CLASS>
val floatingPointAssertions: <ERROR CLASS>
val iterableAssertions: <ERROR CLASS>
val mapAssertions: <ERROR CLASS>
val throwableAssertions: <ERROR CLASS>
package ch.tutteli.atrium.domain.creating.any.typetransformation
package ch.tutteli.atrium.domain.creating.any.typetransformation.creators
Module Contents
interface AnyTypeTransformationAssertions
Module Contents
abstract fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: FailureHandler<T, TSub>): Unit
abstract fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
abstract fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreator: AssertionPlant<T>.() -> Unit): Unit
abstract fun <S : Any, T : Any> transform(parameterObject: ParameterObject<S, T>, canBeTransformed: (S) -> Boolean, transform: (S) -> T, failureHandler: FailureHandler<S, T>): Unit
val anyAssertions: <ERROR CLASS>
val anyTypeTransformationAssertions: <ERROR CLASS>
package ch.tutteli.atrium.domain.creating.any.typetransformation.failurehandlers
package ch.tutteli.atrium.domain.creating.basic.contains
package ch.tutteli.atrium.domain.creating.charsequence.contains
package ch.tutteli.atrium.domain.creating.charsequence.contains.checkers
package ch.tutteli.atrium.domain.creating.charsequence.contains.creators
Module Contents
interface CharSequenceContainsAssertions
Module Contents
abstract fun <T : CharSequence> defaultTranslationOf(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> regex(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> regexIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> values(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Any>): AssertionGroup
abstract fun <T : CharSequence> valuesIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Any>): AssertionGroup
val charSequenceContainsAssertions: <ERROR CLASS>
package ch.tutteli.atrium.domain.creating.charsequence.contains.searchbehaviours
package ch.tutteli.atrium.domain.creating.collectors
package ch.tutteli.atrium.domain.creating.iterable.contains
Module Contents
interface IterableContains
Module Contents
interface Builder<out E, out T : Iterable<E>, out S : SearchBehaviour> : Builder<T, S>
interface Checker : Checker
interface CheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<T, S, Checker, Builder<E, T, S>>
interface Creator<in T : Iterable<*>, in SC> : Creator<T, SC>
interface SearchBehaviour : SearchBehaviour
fun <E, T : Iterable<E>, S : SearchBehaviour> CheckerOption<E, T, S>.addAssertion(assertion: Assertion): AssertionPlant<T>
package ch.tutteli.atrium.domain.creating.iterable.contains.checkers
package ch.tutteli.atrium.domain.creating.iterable.contains.creators
Module Contents
interface IterableContainsAssertions
Module Contents
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<AssertionPlant<E>.() -> Unit>>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnly(builder: Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion
val iterableContainsAssertions: <ERROR CLASS>
package ch.tutteli.atrium.domain.creating.iterable.contains.searchbehaviours
Module Contents
interface InAnyOrderOnlySearchBehaviour : SearchBehaviour
interface InAnyOrderSearchBehaviour : SearchBehaviour
interface InOrderOnlyGroupedSearchBehaviour : SearchBehaviour
interface InOrderOnlyGroupedWithinSearchBehaviour : InOrderOnlyGroupedSearchBehaviour
interface InOrderOnlySearchBehaviour : SearchBehaviour
interface InOrderSearchBehaviour : SearchBehaviour
interface NoOpSearchBehaviour : SearchBehaviour
interface NotSearchBehaviour : InAnyOrderSearchBehaviour
interface SearchBehaviourFactory
Module Contents
abstract fun <E, T : Iterable<E>> inAnyOrder(builder: Builder<E, T, NoOpSearchBehaviour>): Builder<E, T, InAnyOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inAnyOrderOnly(builder: Builder<E, T, InAnyOrderSearchBehaviour>): Builder<E, T, InAnyOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrder(builder: Builder<E, T, NoOpSearchBehaviour>): Builder<E, T, InOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnly(builder: Builder<E, T, InOrderSearchBehaviour>): Builder<E, T, InOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlySearchBehaviour>): Builder<E, T, InOrderOnlyGroupedSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>
val searchBehaviourFactory: <ERROR CLASS>
package ch.tutteli.atrium.domain.creating.throwable.thrown
package ch.tutteli.atrium.domain.creating.throwable.thrown.creators
package ch.tutteli.atrium.domain.creating.throwable.thrown.providers
package ch.tutteli.atrium.reporting
package ch.tutteli.atrium.reporting.translating
package ch.tutteli.atrium.spec
package ch.tutteli.atrium.translations
package ch.tutteli.atrium.verbs
package ch.tutteli.atrium.verbs.assert
package ch.tutteli.atrium.verbs.assertthat
package ch.tutteli.atrium.verbs.expect
package ch.tutteli.atrium.verbs.internal